package com.example.project.utils;

import java.security.SecureRandom;
import java.util.Base64;
import java.util.UUID;

/**
 * Redmine工具类，提供与Redmine兼容的实用方法
 * 
 * @author ruoyi
 */
public class RedmineUtils {
    
    private static final SecureRandom random = new SecureRandom();
    private static final String HEX_CHARS = "0123456789abcdef";
    
    /**
     * 生成指定长度的随机十六进制字符串
     * 类似Ruby中的Redmine::Utils.random_hex方法
     * 
     * @param length 字符串长度
     * @return 随机十六进制字符串
     */
    public static String generateHex(int length) {
        if (length <= 0) {
            throw new IllegalArgumentException("Length must be positive");
        }
        
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append(HEX_CHARS.charAt(random.nextInt(HEX_CHARS.length())));
        }
        return sb.toString();
    }
    
    /**
     * 生成随机令牌（类似Redmine中的API令牌）
     * 
     * @return 随机令牌字符串
     */
    public static String generateToken() {
        byte[] bytes = new byte[32];
        random.nextBytes(bytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }
    
    /**
     * 生成UUID字符串（去除连字符）
     * 
     * @return UUID字符串
     */
    public static String generateUUID() {
        return UUID.randomUUID().toString().replace("-", "");
    }
    
    /**
     * 检查字符串是否为有效的十六进制字符串
     * 
     * @param str 要检查的字符串
     * @return 是否为有效的十六进制字符串
     */
    public static boolean isValidHex(String str) {
        if (str == null || str.isEmpty()) {
            return false;
        }
        
        for (char c : str.toCharArray()) {
            if (HEX_CHARS.indexOf(c) == -1) {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 将字节数组转换为十六进制字符串
     * 
     * @param bytes 字节数组
     * @return 十六进制字符串
     */
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            sb.append(HEX_CHARS.charAt((b & 0xF0) >> 4));
            sb.append(HEX_CHARS.charAt(b & 0x0F));
        }
        return sb.toString();
    }
    
    /**
     * 将十六进制字符串转换为字节数组
     * 
     * @param hex 十六进制字符串
     * @return 字节数组
     */
    public static byte[] hexToBytes(String hex) {
        if (hex == null || hex.length() % 2 != 0) {
            throw new IllegalArgumentException("Invalid hex string");
        }
        
        int len = hex.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
                                 + Character.digit(hex.charAt(i + 1), 16));
        }
        return data;
    }
    
    /**
     * 生成安全的随机数（类似Redmine中的安全随机数生成）
     * 
     * @param min 最小值（包含）
     * @param max 最大值（包含）
     * @return 随机数
     */
    public static int secureRandomInt(int min, int max) {
        if (min > max) {
            throw new IllegalArgumentException("Min must be less than or equal to max");
        }
        return random.nextInt((max - min) + 1) + min;
    }
    
    /**
     * 生成随机文件名（类似Redmine中的附件文件名生成）
     * 
     * @param originalFilename 原始文件名
     * @return 随机文件名
     */
    public static String generateRandomFilename(String originalFilename) {
        String extension = "";
        if (originalFilename != null && originalFilename.contains(".")) {
            extension = originalFilename.substring(originalFilename.lastIndexOf("."));
        }
        return generateHex(16) + extension;
    }
}